PolyData

class PolyData(*args, **kwargs)

Dataset consisting of surface geometry (for example, vertices, lines, and polygons).

The surface geometry is defined by its points and four separate cell connectivity arrays:

• verts for 0-dimensional VERTEX and POLY_VERTEX cells.

• lines for 1-dimensional LINE and POLY_LINE cells.

• faces for 2-dimensional TRIANGLE, QUAD, and POLYGON cells.

• strips for 2-dimensional TRIANGLE_STRIP cells.

Cell types can be mixed, and any combination of cell connectivity arrays may be specified.

PolyData can be initialized in several ways:

• Create an empty mesh

• Initialize from a vtkPolyData

• Using points only

• Using points with verts, faces, lines, and/or strips

• From a file

If a points array is provided with no cell connectivity, the verts connectivity is populated by default, and each point is automatically associated with a single VERTEX to create a point cloud where n_verts equals n_points.

Parameters:

var_inpvtkPolyData, str, sequence, optional

Flexible input type. Can be a vtkPolyData, in which case this PolyData object will be copied if deep=True and will be a shallow copy if deep=False.

Also accepts a path, which may be local path as in 'my_mesh.stl' or global path like '/tmp/my_mesh.ply' or 'C:/Users/user/my_mesh.ply'.

Otherwise, this must be a points array or list containing one or more points. Each point must have 3 dimensions. If faces, lines, strips, and verts are all None, then the PolyData object will be created with vertex cells with n_verts equal to the number of points.

facesCellArrayLike, optional

Connectivity of polygonal faces. Can be either a padded connectivity array or an explicit cell array object.

In the padded array format, faces must contain padding indicating the number of points in the face. For example, the two faces [10, 11, 12] and [20, 21, 22, 23] will be represented as [3, 10, 11, 12, 4, 20, 21, 22, 23]. This lets you have an arbitrary number of points per face.

linesCellArrayLike, optional

Connectivity of lines. Like faces, this can be either a padded connectivity array or an explicit cell array object. The padded array format requires padding indicating the number of points in a line segment. For example, the two line segments [0, 1] and [1, 2, 3, 4] will be represented as [2, 0, 1, 4, 1, 2, 3, 4].

stripsCellArrayLike optional

Connectivity of triangle strips. Triangle strips require an initial triangle, and the following points of the strip. Each triangle is built with the new point and the two previous points.

Just as in lines and faces, this connectivity can be specified as either a padded array or an explicit cell array object. The padded array requires a padding indicating the number of points. For example, a single triangle strip of the 10 point indices [0, 1, 2, 3, 6, 7, 4, 5, 0, 1] requires padding of 10 and should be input as [10, 0, 1, 2, 3, 6, 7, 4, 5, 0, 1].

deepbool, optional

Whether to copy the inputs, or to create a mesh from them without copying them. Setting deep=True ensures that the original arrays can be modified outside the mesh without affecting the mesh. Default is False.

force_extstr, optional

If initializing from a file, force the reader to treat the file as if it had this extension as opposed to the one in the file.

force_floatbool, optional

Casts the datatype to float32 if points datatype is non-float. Default True. Set this to False to allow non-float types, though this may lead to truncation of intermediate floats when transforming datasets.

vertsCellArrayLike, optional

The verts connectivity. Like faces, lines, and strips this can be supplied as either a padded array or an explicit cell array object. In the padded array format, the padding indicates the number of vertices in each cell. For example, [1, 0, 1, 1, 1, 2] indicates three vertex cells each with one point, and [2, 0, 1, 2, 2, 3] indicates two polyvertex cells each with two points.

validatebool | MeshValidationFields | sequence[MeshValidationFields], default: False

Validate the mesh using validate_mesh() after initialization. Set this to True to validate all fields, or specify any combination of fields allowed by validate_mesh.

Added in version 0.47.

Examples

Download Python source code | Download Jupyter notebook

>>> import vtk
>>> import numpy as np
>>> from pyvista import examples
>>> import pyvista as pv

Seed random number generator for reproducible plots

>>> rng = np.random.default_rng(seed=0)

Create an empty mesh.

>>> mesh = pv.PolyData()

Initialize from a vtkPolyData object.

>>> vtkobj = vtk.vtkPolyData()
>>> mesh = pv.PolyData(vtkobj)

Initialize from just points, creating vertices

>>> points = np.array([[0, 0, 0], [1, 0, 0], [1, 0.5, 0], [0, 0.5, 0]])
>>> mesh = pv.PolyData(points)

Initialize from points and faces, creating polygonal faces.

>>> faces = np.hstack([[3, 0, 1, 2], [3, 0, 3, 2]])
>>> mesh = pv.PolyData(points, faces)

Initialize from points and lines.

>>> lines = np.hstack([[2, 0, 1], [2, 1, 2]])
>>> mesh = pv.PolyData(points, lines=lines)

Initialize from points and triangle strips.

>>> strips = np.hstack([[4, 0, 1, 3, 2]])
>>> mesh = pv.PolyData(points, strips=strips)

It is also possible to create with multiple cell types.

>>> verts = [1, 0]
>>> lines = [2, 1, 2]
>>> mesh = pv.PolyData(points, verts=verts, lines=lines)

Initialize from a filename.

>>> mesh = pv.PolyData(examples.antfile)

Construct a set of random line segments using a pv.CellArray. Because every line in this example has the same size, in this case two points, we can use pv.CellArray.from_regular_cells to construct the lines cell array. This is the most efficient method to construct a cell array.

>>> n_points = 20
>>> n_lines = n_points // 2
>>> points = rng.random((n_points, 3))
>>> lines = rng.integers(low=0, high=n_points, size=(n_lines, 2))
>>> mesh = pv.PolyData(points, lines=pv.CellArray.from_regular_cells(lines))
>>> mesh.cell_data['line_idx'] = np.arange(n_lines)
>>> mesh.plot(scalars='line_idx')

Static Scene

Interactive Scene

Construct a set of random triangle strips using a pv.CellArray. Because each strip in this example can have a different number of points, we use pv.CellArray.from_irregular_cells to construct the strips cell array.

>>> n_strips = 4
>>> n_verts_per_strip = rng.integers(low=3, high=7, size=n_strips)
>>> n_points = 10 * sum(n_verts_per_strip)
>>> points = rng.random((n_points, 3))
>>> strips = [
...     rng.integers(low=0, high=n_points, size=nv) for nv in n_verts_per_strip
... ]
>>> mesh = pv.PolyData(
...     points, strips=pv.CellArray.from_irregular_cells(strips)
... )
>>> mesh.cell_data['strip_idx'] = np.arange(n_strips)
>>> mesh.plot(show_edges=True, scalars='strip_idx')

Static Scene

Interactive Scene

Construct a mesh reusing the faces pv.CellArray from another mesh. The VTK methods GetPolys, GetLines, GetStrips, and GetVerts return the underlying CellArray objects for the faces, lines, strips, and verts properties respectively. Reusing cell arrays like this can be a performance optimization for large meshes because it avoids allocating new arrays.

>>> small_sphere = pv.Sphere().compute_normals()
>>> inflated_points = (
...     small_sphere.points + 0.1 * small_sphere.point_data['Normals']
... )
>>> larger_sphere = pv.PolyData(inflated_points, faces=small_sphere.GetPolys())
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(small_sphere, color='red', show_edges=True)
>>> _ = pl.add_mesh(larger_sphere, color='blue', opacity=0.3, show_edges=True)
>>> pl.show()

Static Scene

Interactive Scene

See Also

pyvista.PolyData.from_regular_faces

pyvista.PolyData.from_irregular_faces

Used In

Guides

• PyVista Data Model (4 uses)
• Transitioning From VTK to PyVista (2 uses)
• Overview (1 use)
• What Is a Mesh? (1 use)

Docstring Examples

• Actor.clear_point_sprite_shape (1 use)
• Actor.disable_maximum_intensity_projection (1 use)
• Actor.enable_maximum_intensity_projection (1 use)
• Actor.set_point_sprite_shape (1 use)
• DataObjectFilters.sample (1 use)
• 32 more

  • DataSet.is_empty (1 use)
  • DataSetFilters.interpolate (1 use)
  • DataSetFilters.sample_over_line (1 use)
  • DataSetFilters.sample_over_multiple_lines (1 use)
  • MultiBlock.clean (1 use)
  • MultiBlock.flatten (1 use)
  • MultiBlock.get (1 use)
  • MultiBlock.get_block (1 use)
  • Plotter.add_mesh (1 use)
  • Plotter.export_gltf (1 use)
  • PointGaussianMapper.scale_array (1 use)
  • PolyData.n_faces (1 use)
  • PolyData.n_strips (1 use)
  • PolyData.n_verts (1 use)
  • PolyData.vert_connectivity (1 use)
  • PolyData.vert_offsets (1 use)
  • PolyData.verts (1 use)
  • PolyDataFilters.clean (1 use)
  • PolyDataFilters.decimate_polyline (1 use)
  • PolyDataFilters.delaunay_2d (1 use)
  • PolyDataFilters.remove_unused_points (1 use)
  • PolyDataFilters.ribbon (1 use)
  • PolyDataFilters.ruled_surface (1 use)
  • PolyDataFilters.subdivide_adaptive (1 use)
  • Readers and Writers (1 use)
  • Theme.allow_empty_mesh (1 use)
  • Transform.apply (1 use)
  • UnstructuredGridFilters.delaunay_2d (1 use)
  • allow_new_attributes (1 use)
  • register_dataset_accessor (1 use)
  • set_new_attribute (1 use)
  • vtk_snake_case (1 use)

Gallery Examples

Creating a Spline

Creating a Spline

6 uses

Create Sphere Mesh Multiple Ways

Create Sphere Mesh Multiple Ways

3 uses

Create Triangulated Surface

Create Triangulated Surface

3 uses

Extending PyVista

Extending PyVista

3 uses

Compare Interpolation/Sampling Methods

Compare Interpolation/Sampling Methods

2 uses

Create Point Cloud

Create Point Cloud

2 uses

Create PolyData

Create PolyData

2 uses

Creating a Structured Surface

Creating a Structured Surface

2 uses

Extrude Rotation

Extrude Rotation

2 uses

Project Points to a Plane and Tessellate

Project Points to a Plane and Tessellate

2 uses

Sphere Widget

Sphere Widget

2 uses

Analyze the Orientation of a Point Cloud

Analyze the Orientation of a Point Cloud

1 use

Compare Threshold Filters

Compare Threshold Filters

1 use

Create a Kochanek Spline

Create a Kochanek Spline

1 use

Decimation

Decimation

1 use

Drape 2D Surface From Line

Drape 2D Surface From Line

1 use

Farthest Point Sampling

Farthest Point Sampling

1 use

Highlight Nearest Neighbors in a Point Cloud

Highlight Nearest Neighbors in a Point Cloud

1 use

Label Points

Label Points

1 use

Measure Distance Between Point Clouds

Measure Distance Between Point Clouds

1 use

Mesh Validation

Mesh Validation

1 use

Multiple Slider Widgets

Multiple Slider Widgets

1 use

Plot Atomic Orbitals

Plot Atomic Orbitals

1 use

Plot Truss-Like FEA Solution With Cylinders

Plot Truss-Like FEA Solution With Cylinders

1 use

Point Sprite Shapes

Point Sprite Shapes

1 use

Ray Tracing

Ray Tracing

1 use

Scaled Gaussian Points

Scaled Gaussian Points

1 use

Triangle Strips

Triangle Strips

1 use

Visualize the Moeller-Trumbore Algorithm

Visualize the Moeller-Trumbore Algorithm

1 use

Wrap a Point Cloud in a Convex Hull

Wrap a Point Cloud in a Convex Hull

1 use

Inheritance

Inherited members are documented on _PointSetBase, DataSet, _BoundsSizeMixin, PolyDataFilters, DataSetFilters, DataObjectFilters, DataObject.

See them all under Inherited Attributes, Inherited Methods and Filters.

Wraps vtkPolyData.

Attributes

PolyData.cell_normals	Return the cell normals.
PolyData.face_connectivity	Return the connectivity array of the polygonal faces.
PolyData.face_normals	Return the cell normals.
PolyData.face_offsets	Return the offsets array of the polygonal faces.
PolyData.faces	Return the polygonal faces padded connectivity array.
PolyData.irregular_faces	Return a tuple of face arrays.
PolyData.is_all_triangles	Return if all the faces of the pyvista.PolyData are triangles.
PolyData.is_manifold	Return if the mesh is manifold (no open edges).
PolyData.line_connectivity	Return the connectivity array of the line cells.
PolyData.line_offsets	Return the offsets array of the line cells.
PolyData.lines	Return the lines connectivity array.
PolyData.n_faces	Return the number of polygonal faces.
PolyData.n_faces_strict	Return the number of polygonal faces.
PolyData.n_lines	Return the number of line cells.
PolyData.n_open_edges	Return the number of open edges on this mesh.
PolyData.n_strips	Return the number of triangle strips.
PolyData.n_verts	Return the number of vertex cells.
PolyData.obbTree	Return the OBB tree of the polydata.
PolyData.point_normals	Return the point normals.
PolyData.regular_faces	Return a face array of point indices when all faces have the same size.
PolyData.strip_connectivity	Return the connectivity array of the triangle strips.
PolyData.strip_offsets	Return the offsets array of the triangle strips.
PolyData.strips	Return or set the strips padded connectivity array.
PolyData.vert_connectivity	Return the connectivity array of the vertex cells.
PolyData.vert_offsets	Return the offsets array of the vertex cells.
PolyData.verts	Return or set the vertex padded connectivity array.
PolyData.volume	Return the approximate volume of the dataset.

Inherited Attributes

DataSet.active_normals	Return the active normals as an array.
DataSet.active_scalars	Return the active scalars as an array.
DataSet.active_scalars_info	Return the active scalar’s association and name.
DataSet.active_scalars_name	Return the name of the active scalars.
DataSet.active_tensors	Return the active tensors array.
DataSet.active_tensors_info	Return the active tensor’s field and name: [field, name].
DataSet.active_tensors_name	Return the name of the active tensor array.
DataSet.active_texture_coordinates	Return the active texture coordinates on the points.
DataSet.active_vectors	Return the active vectors array.
DataSet.active_vectors_info	Return the active vector’s association and name.
DataSet.active_vectors_name	Return the name of the active vectors array.
DataObject.actual_memory_size	Return the actual size of the dataset object.
DataSet.area	Return the mesh area if 2D.
DataSet.array_names	Return a list of array names for the dataset.
DataSet.arrows	Return a glyph representation of the active vector data as arrows.
DataSet.bounding_sphere	Compute the radius and center of a bounding sphere.
DataSet.bounds	Return the bounding box of this dataset.
_BoundsSizeMixin.bounds_size	Return the size of each axis of the object’s bounding box.
DataSet.cell	A generator that provides an easy way to loop over all cells.
DataSet.cell_data	Return cell data as DataSetAttributes.
DataSet.center	Set or return the center of the bounding box.
DataSet.dimensionality	Return the number of spatial dimensions spanned by this dataset’s points.
DataSet.distinct_cell_types	Return the set of distinct cell types in this dataset.
DataObject.field_data	Return FieldData as DataSetAttributes.
DataSet.has_nonlinear_cells	Return True if the mesh contains any non-linear cells.
DataSet.is_empty	Return True if there are no points.
DataSet.length	Return the length of the diagonal of the bounding box.
DataSet.max_cell_dimensionality	Return the maximum spatial dimensionality of all cells in this mesh.
DataObject.memory_address	Get address of the underlying VTK C++ object.
DataSet.min_cell_dimensionality	Get the minimum spatial dimensionality of all cells in this mesh.
DataSet.n_arrays	Return the number of arrays present in the dataset.
DataSet.n_cells	Return the number of cells in the entire dataset.
DataSet.n_points	Return the number of points in the entire dataset.
DataSet.number_of_cells	Return the number of cells.
DataSet.number_of_points	Return the number of points.
DataSet.point_data	Return point data as DataSetAttributes.
DataSet.points	Return a reference to the points as a NumPy object.
DataObject.user_dict	Set or return a user-specified data dictionary.

Methods

PolyData.from_irregular_faces(points, faces)	Alternate pyvista.PolyData constructor from points and ragged face arrays.
PolyData.from_regular_faces(points, faces[, ...])	Alternate pyvista.PolyData constructor from points and regular face arrays.
PolyData.save(filename[, binary, texture, ...])	Write a surface mesh to disk.

Inherited Methods

DataObject.add_field_data	Add field data.
DataObject.cast_to_multiblock	Convert this DataObject to a MultiBlock.
DataSet.cast_to_pointset	Extract the points of this dataset and return a pyvista.PointSet.
DataSet.cast_to_poly_points	Extract the points of this dataset and return a pyvista.PolyData.
DataSet.cast_to_unstructured_grid	Get a new representation of this object as a UnstructuredGrid.
DataSet.cell_neighbors	Get the cell neighbors of the ind-th cell.
DataSet.cell_neighbors_levels	Get consecutive levels of cell neighbors.
_PointSetBase.center_of_mass	Return the coordinates for the center of mass of the mesh.
DataSet.clear_cell_data	Remove all cell arrays.
DataSet.clear_data	Remove all arrays from point/cell/field data.
DataObject.clear_field_data	Remove all field data.
DataSet.clear_point_data	Remove all point arrays.
DataObject.copy	Return a copy of the object.
DataObject.copy_attributes	Copy the data attributes of the input dataset object.
DataSet.copy_from	Overwrite this dataset in-place with the new dataset’s geometries and data.
DataSet.copy_meta_from	Copy pyvista meta data onto this object from another object.
DataObject.copy_structure	Copy the structure (geometry and topology) of the input dataset object.
DataObject.deep_copy	Overwrite this data object with another data object as a deep copy.
DataSet.find_cells_along_line	Find the index of cells whose bounds intersect a line.
DataSet.find_cells_intersecting_line	Find the index of cells that intersect a line.
DataSet.find_cells_within_bounds	Find the index of cells in this mesh within bounds.
DataSet.find_closest_cell	Find index of closest cell in this mesh to the given point.
DataSet.find_closest_point	Find index of closest point in this mesh to the given point.
DataSet.find_containing_cell	Find index of a cell that contains the given point.
DataSet.get_array	Search both point, cell, and field data for an array.
DataSet.get_array_association	Get the association of an array.
DataSet.get_cell	Return a pyvista.Cell object.
DataSet.get_data_range	Get the min and max of a named array.
DataObject.head	Return the header stats of this dataset.
DataSet.intersect_with_line	Locate points and cell ids that intersect a line.
DataSet.plot	Plot a PyVista, NumPy, or VTK object.
DataSet.point_cell_ids	Get the cell IDs that use the ind-th point.
DataSet.point_is_inside_cell	Return whether one or more points are inside a cell.
DataSet.point_neighbors	Get the point neighbors of the ind-th point.
DataSet.point_neighbors_levels	Get consecutive levels of point neighbors.
_PointSetBase.points_to_double	Convert the points datatype to double precision.
_PointSetBase.remove_cells	Remove cells.
DataSet.rename_array	Change array name by searching for the array then renaming it.
DataSet.set_active_scalars	Find the scalars by name and appropriately sets it as active.
DataSet.set_active_tensors	Find the tensors by name and appropriately sets it as active.
DataSet.set_active_vectors	Find the vectors by name and appropriately sets it as active.
_PointSetBase.shallow_copy	Create a shallow copy from a different dataset into this one.
DataSet.to_arrow	Return this dataset’s point or cell arrays as a pyarrow.Table.
DataSet.to_pandas	Return this dataset’s point or cell arrays as a pandas.DataFrame.

Filters

DataSetFilters.align	Align a dataset to another.
DataSetFilters.align_xyz	Align a dataset to the x-y-z axes.
PolyDataFilters.append_polydata	Append one or more PolyData into this one.
PolyDataFilters.boolean_difference	Perform a boolean difference operation between two meshes.
PolyDataFilters.boolean_intersection	Perform a boolean intersection operation on two meshes.
PolyDataFilters.boolean_union	Perform a boolean union operation on two meshes.
DataSetFilters.bounding_box	Return a bounding box for this dataset.
DataObjectFilters.cell_centers	Generate points at the center of the cells in this dataset.
DataObjectFilters.cell_data_to_point_data	Transform cell data into point data.
DataObjectFilters.cell_quality	Compute a function of (geometric) quality for each cell of a mesh.
DataObjectFilters.cell_validator	Check the validity of each cell in this dataset.
PolyDataFilters.clean	Clean the mesh.
DataObjectFilters.clip	Clip a dataset by a plane by specifying the origin and normal.
DataObjectFilters.clip_box	Clip a dataset by a bounding box defined by the bounds.
PolyDataFilters.clip_closed_surface	Clip a closed polydata surface with a plane.
DataSetFilters.clip_scalar	Clip a dataset by a scalar.
DataObjectFilters.clip_slab	Clip a dataset by a slab of finite thickness around a plane.
DataSetFilters.clip_surface	Clip any mesh type using a pyvista.PolyData surface mesh.
PolyDataFilters.collision	Perform collision determination between two polyhedral surfaces.
DataSetFilters.color_labels	Add RGB(A) scalars to labeled data.
PolyDataFilters.compute_arc_length	Compute the arc length over the length of the probed line.
DataSetFilters.compute_boundary_mesh_quality	Compute metrics on the boundary faces of a mesh.
DataObjectFilters.compute_cell_sizes	Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
DataSetFilters.compute_derivative	Compute derivative-based quantities of point/cell scalar field.
DataSetFilters.compute_implicit_distance	Compute the implicit distance from the points to a surface.
PolyDataFilters.compute_normals	Compute point and/or cell normals for a mesh.
DataSetFilters.connectivity	Find and label connected regions.
DataSetFilters.contour	Contour an input self by an array.
PolyDataFilters.contour_banded	Generate filled contours.
DataObjectFilters.convex_hull	Compute the convex hull from this mesh’s points.
DataObjectFilters.ctp	Transform cell data into point data.
PolyDataFilters.curvature	Return the point-wise curvature of a mesh.
PolyDataFilters.decimate	Reduce the number of triangles in a triangular mesh using vtkQuadricDecimation.
DataSetFilters.decimate_boundary	Return a decimated version of a triangulation of the boundary.
PolyDataFilters.decimate_polyline	Reduce the number of lines in a polyline mesh.
PolyDataFilters.decimate_pro	Reduce the number of triangles in a triangular mesh.
PolyDataFilters.delaunay_2d	Apply a 2D Delaunay filter along the best fitting plane.
DataSetFilters.delaunay_3d	Construct a 3D Delaunay triangulation of the mesh.
PolyDataFilters.edge_mask	Return a mask of the points of a surface mesh with a surface angle greater than angle.
DataObjectFilters.elevation	Generate scalar values on a dataset.
DataSetFilters.explode	Push each individual cell away from the center of the dataset.
DataObjectFilters.extract_all_edges	Extract all the internal/external edges of the dataset as PolyData.
DataSetFilters.extract_cells	Return a subset of the grid.
DataSetFilters.extract_cells_by_type	Extract cells of a specified type.
DataSetFilters.extract_feature_edges	Extract edges from the surface of the mesh.
DataSetFilters.extract_geometry	Extract the outer surface of a volume or structured grid dataset.
DataSetFilters.extract_largest	Extract largest connected set in mesh.
DataSetFilters.extract_points	Return a subset of the grid (with cells) that contains any of the given point indices.
DataObjectFilters.extract_surface	Extract surface geometry of the mesh as PolyData.
DataSetFilters.extract_values	Return a subset of the mesh based on the values of point or cell data.
PolyDataFilters.extrude	Sweep polygonal data creating a “skirt” from free edges.
PolyDataFilters.extrude_rotate	Sweep polygonal data creating “skirt” from free edges/lines, and lines from vertices.
PolyDataFilters.extrude_trim	Extrude polygonal data trimmed by a surface.
PolyDataFilters.fill_holes	Fill holes in a pyvista.PolyData or vtkPolyData object.
PolyDataFilters.flip_faces	Flip the orientation of the faces.
DataObjectFilters.flip_normal	Flip mesh about the normal.
PolyDataFilters.flip_normal_vectors	Flip the direction of the mesh’s point and cell normal vectors.
PolyDataFilters.flip_normals	Flip normals of a triangular mesh by reversing the point ordering.
DataObjectFilters.flip_x	Flip mesh about the x-axis.
DataObjectFilters.flip_y	Flip mesh about the y-axis.
DataObjectFilters.flip_z	Flip mesh about the z-axis.
DataSetFilters.gaussian_splatting	Splat points into a volume using a Gaussian distribution.
PolyDataFilters.geodesic	Calculate the geodesic path between two vertices using Dijkstra’s algorithm.
PolyDataFilters.geodesic_distance	Calculate the geodesic distance between two vertices using Dijkstra’s algorithm.
DataSetFilters.glyph	Copy a geometric representation (called a glyph) to the input dataset.
DataSetFilters.integrate_data	Integrate point and cell data.
DataSetFilters.interpolate	Interpolate values onto this mesh from a given dataset.
PolyDataFilters.intersection	Compute the intersection between two meshes.
PolyDataFilters.merge	Merge this mesh with one or more datasets.
DataSetFilters.merge_points	Merge duplicate points in this mesh.
PolyDataFilters.multi_ray_trace	Perform multiple ray trace calculations.
DataSetFilters.oriented_bounding_box	Return an oriented bounding box (OBB) for this dataset.
DataSetFilters.outline	Produce an outline of the full extent for the input dataset.
DataSetFilters.outline_corners	Produce an outline of the corners for the input dataset.
DataSetFilters.pack_labels	Renumber labeled data such that labels are contiguous.
DataSetFilters.partition	Break down input dataset into a requested number of partitions.
PolyDataFilters.plot_boundaries	Plot boundaries of a mesh.
PolyDataFilters.plot_curvature	Plot the curvature.
PolyDataFilters.plot_normals	Plot the point normals of a mesh.
DataSetFilters.plot_over_circular_arc	Sample a dataset along a circular arc and plot it.
DataSetFilters.plot_over_circular_arc_normal	Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
DataSetFilters.plot_over_line	Sample a dataset along a high resolution line and plot.
DataObjectFilters.point_data_to_cell_data	Transform point data into cell data.
PolyDataFilters.project_points_to_plane	Project points of this mesh to a plane.
PolyDataFilters.protein_ribbon	Generate protein ribbon.
DataObjectFilters.ptc	Transform point data into cell data.
PolyDataFilters.ray_trace	Perform a single ray trace calculation.
PolyDataFilters.reconstruct_surface	Reconstruct a surface from the points in this dataset.
DataObjectFilters.reflect	Reflect a dataset across a plane.
DataSetFilters.remove_nan_cells	Remove cells whose scalar values are NaN.
PolyDataFilters.remove_points	Rebuild a mesh by removing points.
PolyDataFilters.remove_unused_points	Remove points which are not used by any cells.
DataObjectFilters.resize	Resize the dataset’s bounds.
PolyDataFilters.ribbon	Create a ribbon of the lines in this dataset.
DataObjectFilters.rotate	Rotate mesh about a point with a rotation matrix or Rotation object.
DataObjectFilters.rotate_vector	Rotate mesh about a vector.
DataObjectFilters.rotate_x	Rotate mesh about the x-axis.
DataObjectFilters.rotate_y	Rotate mesh about the y-axis.
DataObjectFilters.rotate_z	Rotate mesh about the z-axis.
PolyDataFilters.ruled_surface	Create a ruled surface from a polyline.
DataObjectFilters.sample	Resample array data from a passed mesh onto this mesh.
DataSetFilters.sample_over_circular_arc	Sample a dataset over a circular arc.
DataSetFilters.sample_over_circular_arc_normal	Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
DataSetFilters.sample_over_line	Sample a dataset onto a line.
DataSetFilters.sample_over_multiple_lines	Sample a dataset onto a multiple lines.
DataObjectFilters.scale	Scale the mesh.
DataSetFilters.select_enclosed_points	Mark points as to whether they are inside a closed surface.
DataSetFilters.select_interior_points	Mark points from this mesh as inside or outside relative to a closed surface.
DataSetFilters.separate_cells	Return a copy of the dataset with separated cells with no shared points.
DataSetFilters.shrink	Shrink the individual faces of a mesh.
DataObjectFilters.slice	Slice a dataset by a plane at the specified origin and normal vector orientation.
DataObjectFilters.slice_along_axis	Create many slices of the input dataset along a specified axis.
DataObjectFilters.slice_along_line	Slice a dataset using a polyline/spline as the path.
DataObjectFilters.slice_implicit	Slice a dataset by a VTK implicit function.
DataObjectFilters.slice_orthogonal	Create three orthogonal slices through the dataset on the three Cartesian planes.
PolyDataFilters.smooth	Adjust point coordinates using Laplacian smoothing.
PolyDataFilters.smooth_taubin	Smooth a PolyData DataSet with Taubin smoothing.
DataSetFilters.sort_labels	Sort labeled data by number of points or cells.
DataSetFilters.split_bodies	Find, label, and split connected bodies/volumes.
DataSetFilters.split_values	Split mesh into separate sub-meshes using point or cell data.
DataSetFilters.streamlines	Integrate a vector field to generate streamlines.
DataSetFilters.streamlines_evenly_spaced_2D	Generate evenly spaced streamlines on a 2D dataset.
DataSetFilters.streamlines_from_source	Generate streamlines of vectors from the points of a source mesh.
PolyDataFilters.strip	Strip poly data cells.
PolyDataFilters.subdivide	Increase the number of triangles in a single, connected triangular mesh.
PolyDataFilters.subdivide_adaptive	Increase the number of triangles in a triangular mesh based on edge and/or area metrics.
DataSetFilters.surface_indices	Return the surface indices of a grid.
DataSetFilters.tessellate	Tessellate a mesh.
DataSetFilters.texture_map_to_plane	Texture map this dataset to a user defined plane.
DataSetFilters.texture_map_to_sphere	Texture map this dataset to a user defined sphere.
DataSetFilters.threshold	Apply a vtkThreshold filter to the input dataset.
DataSetFilters.threshold_percent	Threshold the dataset by a percentage of its range on the active scalars array.
DataObjectFilters.transform	Transform this mesh with a 4x4 transform.
DataObjectFilters.translate	Translate the mesh.
PolyDataFilters.triangulate	Return an all triangle mesh.
PolyDataFilters.triangulate_contours	Triangulate and fill all 2D contours to create polygons.
PolyDataFilters.tube	Generate a tube around each input line.
DataObjectFilters.validate_mesh	Validate this mesh’s array data, points, and cells.
DataSetFilters.voxelize	Voxelize mesh to UnstructuredGrid.
DataSetFilters.voxelize_binary_mask	Voxelize mesh as a binary ImageData mask.
DataSetFilters.voxelize_rectilinear	Voxelize mesh to create a RectilinearGrid voxel volume.
DataSetFilters.warp_by_scalar	Warp the dataset’s points by a point data scalars array’s values.
DataSetFilters.warp_by_vector	Warp the dataset’s points by a point data vectors array’s values.