Python VTK 初探数据源-51CTO.COM

VTK提供了许多类型的数据源，用于创建不同类型的几何对象和数据集。以下是一些常见的数据源类型及其功能：

点源：

点源(Point Source)是一种常见的数据源类型之一。点源用于生成位于给定区域内的随机或规则分布的点。VTK中提供了几种不同的点源类，可以根据需求选择适合的类型：

vtkPointSource：

vtkPointSource是最基础的点源类之一。
可以使用SetCenter()方法设置点源的中心坐标。
可以使用SetRadius()方法设置点源生成的点的距离中心的最大半径。
可以使用SetNumberOfPoints()方法设置要生成的点的数量。
生成的点将以随机方式分布在球体内，其半径由SetRadius()确定。

vtkRegularPolygonSource：

vtkRegularPolygonSource可用于生成规则分布的点，它创建一个规则的n边形网格，并以中心为原点。
可以使用SetCenter()方法设置多边形的中心点坐标。
可以使用SetNumberOfSides()方法设置多边形的边数。
可以使用SetRadius()方法设置多边形的半径。
可以使用SetResolution()方法设置多边形的分辨率，即沿着半径方向的点数。

这些点源可以与VTK管线中的其他组件(滤波器、映射器、渲染器等)一起使用，以生成所需的可视化效果。它们是创建简单独立几何对象或用于复杂模型的基本构建块的有用工具。请根据自己的需求选择最适合的点源，并根据需要设置相应的属性。

import vtk

# 创建一个点源
point_source = vtk.vtkPointSource()
point_source.SetNumberOfPoints(100)
point_source.SetCenter(0, 0, 0)
point_source.SetRadius(1.0)
point_source.Update()

# 创建一个正多边形源
polygon_source = vtk.vtkRegularPolygonSource()
polygon_source.SetNumberOfSides(6)
polygon_source.SetRadius(1.0)
polygon_source.SetCenter(0, 0, 0)
polygon_source.Update()

# 创建一个mapper和actor来显示点源
point_mapper = vtk.vtkPolyDataMapper()
point_mapper.SetInputData(point_source.GetOutput())

point_actor = vtk.vtkActor()
point_actor.SetMapper(point_mapper)
point_actor.GetProperty().SetColor(1, 0, 0)  # 设置点的颜色为红色

# 创建一个mapper和actor来显示正多边形源
polygon_mapper = vtk.vtkPolyDataMapper()
polygon_mapper.SetInputData(polygon_source.GetOutput())

polygon_actor = vtk.vtkActor()
polygon_actor.SetMapper(polygon_mapper)
polygon_actor.GetProperty().SetColor(0, 0, 1)  # 设置多边形的颜色为蓝色

# 创建一个渲染器和窗口
renderer = vtk.vtkRenderer()
renderer.AddActor(point_actor)
renderer.AddActor(polygon_actor)

render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)

# 创建一个交互器
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)

# 开始渲染和交互
render_window.Render()
interactor.Start()

表面源：

VTK中的表面源(Surface Source)是用于生成各种几何表面形状的数据源类型。这些表面源可以作为几何模型的基本构建块，在可视化中起到重要的作用。以下是一些常见的表面源及其功能：

vtkCubeSource：

vtkCubeSource用于创建一个立方体。
可以使用SetXLength()、SetYLength()和SetZLength()方法设置立方体在三个轴上的尺寸。

vtkCylinderSource：

vtkCylinderSource用于创建一个圆柱体。
可以使用SetRadius()方法设置圆柱体的底部和顶部圆的半径。
可以使用SetHeight()方法设置圆柱体的高度。
可以使用SetResolution()方法设置圆柱体侧面的分辨率，即周围切片的数量。

vtkSphereSource：

vtkSphereSource用于创建一个球体。
可以使用SetRadius()方法设置球的半径。
可以使用SetThetaResolution()和SetPhiResolution()方法设置球体表面的纬度和经度方向的分辨率。

vtkArrowSource：

vtkArrowSource用于创建一个箭头。
可以使用SetShaftRadius()方法设置箭头的主体(箭杆)的半径。
可以使用SetTipRadius()方法设置箭头的顶部尖端的半径。
可以使用SetTipLength()方法设置箭头尖端的长度。
可以使用SetShaftResolution()和SetTipResolution()方法设置箭头主体(箭杆)和顶部尖端的分辨率。

vtkLineSource：

vtkLineSource用于创建一条直线。
可以使用SetPoint1()和SetPoint2()方法设置直线的起点和终点坐标。

vtkPlaneSource：

vtkPlaneSource用于创建一个平面。
可以使用SetOrigin()方法设置平面的原点。
可以使用SetPoint1()和SetPoint2()方法设置平面上的两个点，从而确定平面的大小和方向。

vtkDiskSource：

vtkDiskSource用于创建一个圆盘。
可以使用SetInnerRadius()和SetOuterRadius()方法设置圆盘的内外半径。
可以使用SetRadialResolution()和SetCircumferentialResolution()方法设置圆盘内环和外环的分辨率。

这些表面源提供了不同形状的基本几何对象。通过设置属性和参数，可以调整它们的尺寸、分辨率和其他特征。这些表面源可以用作可视化中的简单几何构件，也可以在复杂模型的构建中使用。请根据自己的需求选择最适合的表面源，并根据需要设置相应的属性。

import vtk

# 创建立方体数据源
cube_source = vtk.vtkCubeSource()
cube_source.Update()

# 创建圆柱体数据源
cylinder_source = vtk.vtkCylinderSource()
cylinder_source.SetRadius(1.0)
cylinder_source.SetHeight(3.0)
cylinder_source.SetResolution(100)
cylinder_source.Update()

# 创建球体数据源
sphere_source = vtk.vtkSphereSource()
sphere_source.SetRadius(1.5)
sphere_source.SetThetaResolution(100)
sphere_source.SetPhiResolution(100)
sphere_source.Update()

# 创建箭头数据源
arrow_source = vtk.vtkArrowSource()
arrow_source.Update()

# 创建渲染器和窗口
renderer1 = vtk.vtkRenderer()
renderer1.SetBackground(0.8, 0.8, 0.8)  # 设置背景颜色为灰色
renderer1.SetViewport(0, 0.5, 0.5, 1)  # 设置渲染器在窗口中的位置和大小

renderer2 = vtk.vtkRenderer()
renderer2.SetBackground(0.7, 0.7, 0.7)  # 设置背景颜色为浅灰色
renderer2.SetViewport(0.5, 0.5, 1, 1)  # 设置渲染器在窗口中的位置和大小

renderer3 = vtk.vtkRenderer()
renderer3.SetBackground(0.6, 0.6, 0.6)  # 设置背景颜色为深灰色
renderer3.SetViewport(0, 0, 0.5, 0.5)  # 设置渲染器在窗口中的位置和大小

renderer4 = vtk.vtkRenderer()
renderer4.SetBackground(0.5, 0.5, 0.5)  # 设置背景颜色为更深灰色
renderer4.SetViewport(0.5, 0, 1, 0.5)  # 设置渲染器在窗口中的位置和大小

render_window = vtk.vtkRenderWindow()
render_window.SetSize(800, 600)
render_window.AddRenderer(renderer1)
render_window.AddRenderer(renderer2)
render_window.AddRenderer(renderer3)
render_window.AddRenderer(renderer4)

# 创建交互器
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)

# 创建立方体的mapper和actor
cube_mapper = vtk.vtkPolyDataMapper()
cube_mapper.SetInputData(cube_source.GetOutput())

cube_actor = vtk.vtkActor()
cube_actor.SetMapper(cube_mapper)
cube_actor.GetProperty().SetColor(1, 0, 0)  # 设置立方体的颜色为红色

# 创建圆柱体的mapper和actor
cylinder_mapper = vtk.vtkPolyDataMapper()
cylinder_mapper.SetInputData(cylinder_source.GetOutput())

cylinder_actor = vtk.vtkActor()
cylinder_actor.SetMapper(cylinder_mapper)
cylinder_actor.GetProperty().SetColor(0, 1, 0)  # 设置圆柱体的颜色为绿色

# 创建球体的mapper和actor
sphere_mapper = vtk.vtkPolyDataMapper()
sphere_mapper.SetInputData(sphere_source.GetOutput())

sphere_actor = vtk.vtkActor()
sphere_actor.SetMapper(sphere_mapper)
sphere_actor.GetProperty().SetColor(0, 0, 1)  # 设置球体的颜色为蓝色

# 创建箭头的mapper和actor
arrow_mapper = vtk.vtkPolyDataMapper()
arrow_mapper.SetInputData(arrow_source.GetOutput())

arrow_actor = vtk.vtkActor()
arrow_actor.SetMapper(arrow_mapper)
arrow_actor.GetProperty().SetColor(1, 1, 0)  # 设置箭头的颜色为黄色

# 将actor添加到各自的渲染器中
renderer1.AddActor(cube_actor)
renderer2.AddActor(cylinder_actor)
renderer3.AddActor(sphere_actor)
renderer4.AddActor(arrow_actor)

# 开始渲染和交互
render_window.Render()
interactor.Start()

import vtk

# 创建线段数据源
line_source = vtk.vtkLineSource()
line_source.SetPoint1(-1.0, 0.0, 0.0)
line_source.SetPoint2(1.0, 0.0, 0.0)
line_source.Update()

# 创建平面数据源
plane_source = vtk.vtkPlaneSource()
plane_source.SetOrigin(-1.0, -1.0, 0.0)
plane_source.SetPoint1(1.0, -1.0, 0.0)
plane_source.SetPoint2(-1.0, 1.0, 0.0)
plane_source.SetResolution(10, 10)
plane_source.Update()

# 创建圆盘数据源
disk_source = vtk.vtkDiskSource()
disk_source.SetInnerRadius(0.5)
disk_source.SetOuterRadius(1.0)
disk_source.SetRadialResolution(100)
disk_source.SetCircumferentialResolution(100)
disk_source.Update()

# 创建渲染器和窗口
renderer1 = vtk.vtkRenderer()
renderer1.SetBackground(0.8, 0.8, 0.8)
renderer1.SetViewport(0, 0.5, 0.5, 1)

renderer2 = vtk.vtkRenderer()
renderer2.SetBackground(0.7, 0.7, 0.7)
renderer2.SetViewport(0.5, 0.5, 1, 1)

renderer3 = vtk.vtkRenderer()
renderer3.SetBackground(0.6, 0.6, 0.6)
renderer3.SetViewport(0, 0, 0.5, 0.5)

render_window = vtk.vtkRenderWindow()
render_window.SetSize(800, 600)
render_window.AddRenderer(renderer1)
render_window.AddRenderer(renderer2)
render_window.AddRenderer(renderer3)

# 创建交互器
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)

# 创建线段的mapper和actor
line_mapper = vtk.vtkPolyDataMapper()
line_mapper.SetInputData(line_source.GetOutput())

line_actor = vtk.vtkActor()
line_actor.SetMapper(line_mapper)
line_actor.GetProperty().SetColor(1, 0, 0)

# 创建平面的mapper和actor
plane_mapper = vtk.vtkPolyDataMapper()
plane_mapper.SetInputData(plane_source.GetOutput())

plane_actor = vtk.vtkActor()
plane_actor.SetMapper(plane_mapper)
plane_actor.GetProperty().SetColor(0, 1, 0)

# 创建圆盘的mapper和actor
disk_mapper = vtk.vtkPolyDataMapper()
disk_mapper.SetInputData(disk_source.GetOutput())

disk_actor = vtk.vtkActor()
disk_actor.SetMapper(disk_mapper)
disk_actor.GetProperty().SetColor(0, 0, 1)

# 将actor添加到各自的渲染器中
renderer1.AddActor(line_actor)
renderer2.AddActor(plane_actor)
renderer3.AddActor(disk_actor)

# 开始渲染和交互
render_window.Render()
interactor.Start()

数据网格源：

在VTK中，数据网格源(Data Grid Source)用于生成各种类型的数据网格，这些网格可以表示复杂的几何形状和数据结构。以下是一些常见的数据网格源及其功能：

vtkImageData：

vtkImageData用于创建规则结构化的数据网格。
可以使用SetDimensions()方法设置数据网格的尺寸，即在三个维度上的像素数。
可以使用SetSpacing()方法设置数据网格中像素之间的间距。
可以使用SetOrigin()方法设置数据网格的原点坐标。

import vtk

# 创建vtkImageData数据源
image_data = vtk.vtkImageData()
image_data.SetDimensions(10, 10, 1)
image_data.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1)
for i in range(10):
    for j in range(10):
        pixel_value = int((i+j) % 2) * 255
        image_data.SetScalarComponentFromDouble(i, j, 0, 0, pixel_value)

# 创建渲染器和窗口
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.8, 0.8, 0.8)
render_window = vtk.vtkRenderWindow()
render_window.SetSize(800, 600)
render_window.AddRenderer(renderer)

# 创建交互器
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)

# 创建vtkDataSetMapper和vtkActor
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(image_data)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)

# 开始渲染和交互
render_window.Render()
interactor.Start()

vtkRectilinearGrid：

vtkRectilinearGrid用于创建由直线边界定义的数据网格。
可以使用SetDimensions()方法设置数据网格的尺寸，即在三个维度上的网格单元数。
可以使用SetXCoordinates()、SetYCoordinates()和SetZCoordinates()方法设置每个坐标轴上的边界坐标。

import vtk

# 创建vtkRectilinearGrid数据源
x = vtk.vtkFloatArray()
y = vtk.vtkFloatArray()
z = vtk.vtkFloatArray()
for i in range(10):
    x.InsertNextValue(i)
    y.InsertNextValue(i)
    z.InsertNextValue(0)

rectilinear_grid = vtk.vtkRectilinearGrid()
rectilinear_grid.SetDimensions(10, 10, 1)
rectilinear_grid.SetXCoordinates(x)
rectilinear_grid.SetYCoordinates(y)
rectilinear_grid.SetZCoordinates(z)

# 创建渲染器和窗口
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.8, 0.8, 0.8)
render_window = vtk.vtkRenderWindow()
render_window.SetSize(800, 600)
render_window.AddRenderer(renderer)

# 创建交互器
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)

# 创建vtkDataSetMapper和vtkActor
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(rectilinear_grid)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)

# 开始渲染和交互
render_window.Render()
interactor.Start()

vtkStructuredGrid：

vtkStructuredGrid用于创建由结构化拓扑定义的数据网格。
可以使用SetDimensions()方法设置数据网格的尺寸，即在三个维度上的网格单元数。
可以使用SetPoints()方法设置每个网格单元的坐标。

import vtk

# 创建vtkStructuredGrid数据源
structured_grid = vtk.vtkStructuredGrid()
points = vtk.vtkPoints()
for i in range(10):
    for j in range(10):
        points.InsertNextPoint(i, j, 0)

structured_grid.SetDimensions(10, 10, 1)
structured_grid.SetPoints(points)

# 创建渲染器和窗口
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.8, 0.8, 0.8)
render_window = vtk.vtkRenderWindow()
render_window.SetSize(800, 600)
render_window.AddRenderer(renderer)

# 创建交互器
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)

# 创建vtkDataSetMapper和vtkActor
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(structured_grid)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)

# 开始渲染和交互
render_window.Render()
interactor.Start()

vtkPolyData：

vtkPolyData用于创建具有任意拓扑结构的数据网格。
可以使用SetPoints()方法设置数据网格中的点坐标。
可以使用SetPolys()、SetLines()和SetVerts()等方法设置不同类型的拓扑关系。

import vtk

# 创建vtkPolyData数据源
points = vtk.vtkPoints()
points.InsertNextPoint(0.0, 0.0, 0.0)
points.InsertNextPoint(1.0, 0.0, 0.0)
points.InsertNextPoint(1.0, 1.0, 0.0)
points.InsertNextPoint(0.0, 1.0, 0.0)
poly_data = vtk.vtkPolyData()
poly_data.SetPoints(points)
polygon = vtk.vtkPolygon()
polygon.GetPointIds().SetNumberOfIds(4)
for i in range(4):
    polygon.GetPointIds().SetId(i, i)
polygons = vtk.vtkCellArray()
polygons.InsertNextCell(polygon)
poly_data.SetPolys(polygons)

# 创建渲染器和窗口
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.8, 0.8, 0.8)
render_window = vtk.vtkRenderWindow()
render_window.SetSize(800, 600)
render_window.AddRenderer(renderer)

# 创建交互器
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)

# 创建vtkDataSetMapper和vtkActor
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(poly_data)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)

# 开始渲染和交互
render_window.Render()
interactor.Start()

vtkUnstructuredGrid：

vtkUnstructuredGrid用于创建具有非结构化拓扑结构的数据网格。
可以使用SetPoints()方法设置数据网格中的点坐标。
可以使用SetCells()方法设置不同类型的单元和它们的连接关系。

import vtk

# 创建vtkUnstructuredGrid数据源
points = vtk.vtkPoints()
points.InsertNextPoint(0.0, 0.0, 0.0)
points.InsertNextPoint(1.0, 0.0, 0.0)
points.InsertNextPoint(1.0, 1.0, 0.0)
points.InsertNextPoint(0.0, 1.0, 0.0)
unstructured_grid = vtk.vtkUnstructuredGrid()
unstructured_grid.SetPoints(points)
quad = vtk.vtkQuad()
quad.GetPointIds().SetId(0, 0)
quad.GetPointIds().SetId(1, 1)
quad.GetPointIds().SetId(2, 2)
quad.GetPointIds().SetId(3, 3)
unstructured_grid.InsertNextCell(quad.GetCellType(), quad.GetPointIds())

# 创建渲染器和窗口
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.8, 0.8, 0.8)
render_window = vtk.vtkRenderWindow()
render_window.SetSize(800, 600)
render_window.AddRenderer(renderer)

# 创建交互器
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)

# 创建vtkDataSetMapper和vtkActor
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(unstructured_grid)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)

# 开始渲染和交互
render_window.Render()
interactor.Start()

这些数据网格源提供了不同类型和结构的数据网格。可以根据需要设置各种属性和参数来定义网格的维度、拓扑关系和几何形状。这些数据网格源是VTK中构建复杂模型的基本组件，可以与滤波器、映射器、渲染器等其他组件一起使用，实现各种可视化效果。请根据自己的需求选择最适合的数据网格源，并相应地设置属性。

文件读取器：

在VTK中，文件读取器(File Readers)用于从外部文件读取数据，并将其转换为VTK数据对象。这样可以方便地导入各种常见的数据格式，以便进行可视化和分析。以下是一些常见的文件读取器及其功能：

vtkStructuredPointsReader：

vtkStructuredPointsReader用于读取结构化点数据。
可以使用SetFileName()方法设置要读取的文件名。
可以使用GetOutput()方法获取读取的数据对象。

import vtk

# 创建vtkStructuredPointsReader
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName("structured_points.vtk")
reader.Update()

# 获取读取的数据
structured_points = reader.GetOutput()

# 创建渲染器和窗口
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.8, 0.8, 0.8)
render_window = vtk.vtkRenderWindow()
render_window.SetSize(800, 600)
render_window.AddRenderer(renderer)

# 创建交互器
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)

# 创建vtkDataSetMapper和vtkActor
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(structured_points)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)

# 开始渲染和交互
render_window.Render()
interactor.Start()

vtkRectilinearGridReader：

vtkRectilinearGridReader用于读取直线边界定义的数据网格。
可以使用SetFileName()方法设置要读取的文件名。
可以使用GetOutput()方法获取读取的数据对象。

import vtk

# 创建vtkRectilinearGridReader
reader = vtk.vtkRectilinearGridReader()
reader.SetFileName("rectilinear_grid.vtk")
reader.Update()

# 获取读取的数据
rectilinear_grid = reader.GetOutput()

# 创建渲染器和窗口
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.8, 0.8, 0.8)
render_window = vtk.vtkRenderWindow()
render_window.SetSize(800, 600)
render_window.AddRenderer(renderer)

# 创建交互器
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)

# 创建vtkDataSetMapper和vtkActor
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(rectilinear_grid)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)

# 开始渲染和交互
render_window.Render()
interactor.Start()

vtkStructuredGridReader：

vtkStructuredGridReader用于读取由结构化拓扑定义的数据网格。
可以使用SetFileName()方法设置要读取的文件名。
可以使用GetOutput()方法获取读取的数据对象。

import vtk

# 创建vtkStructuredGridReader
reader = vtk.vtkStructuredGridReader()
reader.SetFileName("structured_grid.vtk")
reader.Update()

# 获取读取的数据
structured_grid = reader.GetOutput()

# 创建渲染器和窗口
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.8, 0.8, 0.8)
render_window = vtk.vtkRenderWindow()
render_window.SetSize(800, 600)
render_window.AddRenderer(renderer)

# 创建交互器
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)

# 创建vtkDataSetMapper和vtkActor
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(structured_grid)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)

# 开始渲染和交互
render_window.Render()
interactor.Start()

vtkPolyDataReader：

vtkPolyDataReader用于读取PolyData格式的数据网格。
可以使用SetFileName()方法设置要读取的文件名。
可以使用GetOutput()方法获取读取的数据对象。

import vtk

# 创建vtkPolyDataReader
reader = vtk.vtkPolyDataReader()
reader.SetFileName("poly_data.vtk")
reader.Update()

# 获取读取的数据
poly_data = reader.GetOutput()

# 创建渲染器和窗口
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.8, 0.8, 0.8)
render_window = vtk.vtkRenderWindow()
render_window.SetSize(800, 600)
render_window.AddRenderer(renderer)

# 创建交互器
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)

# 创建vtkDataSetMapper和vtkActor
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(poly_data)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)

# 开始渲染和交互
render_window.Render()
interactor.Start()

vtkUnstructuredGridReader：

vtkUnstructuredGridReader用于读取非结构化拓扑定义的数据网格。
可以使用SetFileName()方法设置要读取的文件名。
可以使用GetOutput()方法获取读取的数据对象。

import vtk

# 创建vtkUnstructuredGridReader
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName("unstructured_grid.vtk")
reader.Update()

# 获取读取的数据
unstructured_grid = reader.GetOutput()

# 创建渲染器和窗口
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.8, 0.8, 0.8)
render_window = vtk.vtkRenderWindow()
render_window.SetSize(800, 600)
render_window.AddRenderer(renderer)

# 创建交互器
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)

# 创建vtkDataSetMapper和vtkActor
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(unstructured_grid)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)

# 开始渲染和交互
render_window.Render()
interactor.Start()

vtkImageDataReader：

vtkImageDataReader用于读取规则结构化的数据网格。
可以使用SetFileName()方法设置要读取的文件名。
可以使用GetOutput()方法获取读取的数据对象。

import vtk

# 创建vtkImageDataReader
reader = vtk.vtkImageDataReader()
reader.SetFileName("image_data.vtk")
reader.Update()

# 获取读取的数据
image_data = reader.GetOutput()

# 创建渲染器和窗口
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.8, 0.8, 0.8)
render_window = vtk.vtkRenderWindow()
render_window.SetSize(800, 600)
render_window.AddRenderer(renderer)

# 创建交互器
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)

# 创建vtkDataSetMapper和vtkActor
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(image_data)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)

# 开始渲染和交互
render_window.Render()
interactor.Start()

vtkXMLDataReader系列：

vtkXMLDataReader系列用于读取基于XML格式的各种数据网格。
包括vtkXMLPolyDataReader、vtkXMLStructuredGridReader、vtkXMLUnstructuredGridReader等。
可以使用SetFileName()方法设置要读取的文件名。
可以使用GetOutput()方法获取读取的数据对象。

import vtk

# 创建vtkXMLDataReader
reader = vtk.vtkXMLDataReader()
reader.SetFileName("xml_data.vtk")
reader.Update()

# 获取读取的数据
xml_data = reader.GetOutput()

# 创建渲染器和窗口
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.8, 0.8, 0.8)
render_window = vtk.vtkRenderWindow()
render_window.SetSize(800, 600)
render_window.AddRenderer(renderer)

# 创建交互器
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)

# 创建vtkDataSetMapper和vtkActor
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(xml_data)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)

# 开始渲染和交互
render_window.Render()
interactor.Start()

这些文件读取器提供了对不同格式的数据文件进行读取和解析的功能。可以根据所需的数据格式选择相应的读取器，并使用相应的方法来设置文件名和获取读取的数据对象。这样可以方便地将外部数据导入到VTK中，进行后续的可视化和分析处理。